﻿// Copyright (c) Chris Pulman. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.

namespace S7PlcRx.PlcTypes;

/// <summary>
/// Contains the methods to convert between <see cref="T:System.DateTime" /> and S7 representation of DateTimeLong (DTL) values.
/// </summary>
public static class DateTimeLong
{
    /// <summary>
    /// The type length in bytes.
    /// </summary>
    public const int TypeLengthInBytes = 12;

    /// <summary>
    /// The minimum <see cref="T:System.DateTime" /> value supported by the specification.
    /// </summary>
    public static readonly System.DateTime SpecMinimumDateTime = new System.DateTime(1970, 1, 1);

    /// <summary>
    /// The maximum <see cref="T:System.DateTime" /> value supported by the specification.
    /// </summary>
    public static readonly System.DateTime SpecMaximumDateTime = new System.DateTime(2262, 4, 11, 23, 47, 16, 854);

    /// <summary>
    /// Parses a <see cref="T:System.DateTime" /> value from bytes.
    /// </summary>
    /// <param name="bytes">Input bytes read from PLC.</param>
    /// <returns>A <see cref="T:System.DateTime" /> object representing the value read from PLC.</returns>
    /// <exception cref="ArgumentOutOfRangeException">
    /// Thrown when the length of
    /// <paramref name="bytes" /> is not 12 or any value in <paramref name="bytes" />
    /// is outside the valid range of values.
    /// </exception>
    public static System.DateTime FromByteArray(byte[] bytes)
    {
        if (bytes == null)
        {
            throw new ArgumentNullException(nameof(bytes));
        }

        return FromByteArrayImpl(bytes);
    }

    /// <summary>
    /// Parses an array of <see cref="T:System.DateTime" /> values from bytes.
    /// </summary>
    /// <param name="bytes">Input bytes read from PLC.</param>
    /// <returns>An array of <see cref="T:System.DateTime" /> objects representing the values read from PLC.</returns>
    /// <exception cref="ArgumentOutOfRangeException">
    /// Thrown when the length of
    /// <paramref name="bytes" /> is not a multiple of 12 or any value in
    /// <paramref name="bytes" /> is outside the valid range of values.
    /// </exception>
    public static System.DateTime[] ToArray(byte[] bytes)
    {
        if (bytes?.Length % TypeLengthInBytes != 0)
        {
            throw new ArgumentOutOfRangeException(nameof(bytes), bytes!.Length, $"Parsing an array of DateTimeLong requires a multiple of 12 bytes of input data, input data is '{bytes.Length}' long.");
        }

        var cnt = bytes!.Length / TypeLengthInBytes;
        var result = new System.DateTime[cnt];

        for (var i = 0; i < cnt; i++)
        {
            var slice = new byte[TypeLengthInBytes];
            Array.Copy(bytes, i * TypeLengthInBytes, slice, 0, TypeLengthInBytes);
            result[i] = FromByteArrayImpl(slice);
        }

        return result;
    }

    /// <summary>
    /// Converts a <see cref="T:System.DateTime" /> value to a byte array.
    /// </summary>
    /// <param name="dateTime">The DateTime value to convert.</param>
    /// <returns>A byte array containing the S7 DateTimeLong representation of <paramref name="dateTime" />.</returns>
    /// <exception cref="ArgumentOutOfRangeException">
    /// Thrown when the value of
    /// <paramref name="dateTime" /> is before <see cref="P:SpecMinimumDateTime" />
    /// or after <see cref="P:SpecMaximumDateTime" />.
    /// </exception>
    public static byte[] ToByteArray(System.DateTime dateTime)
    {
        if (dateTime < SpecMinimumDateTime)
        {
            throw new ArgumentOutOfRangeException(nameof(dateTime), dateTime, $"Date time '{dateTime}' is before the minimum '{SpecMinimumDateTime}' supported in S7 DateTimeLong representation.");
        }

        if (dateTime > SpecMaximumDateTime)
        {
            throw new ArgumentOutOfRangeException(nameof(dateTime), dateTime, $"Date time '{dateTime}' is after the maximum '{SpecMaximumDateTime}' supported in S7 DateTimeLong representation.");
        }

        var stream = new MemoryStream(TypeLengthInBytes);

        // Convert Year
        stream.Write(Word.ToByteArray(Convert.ToUInt16(dateTime.Year)), 0, 2);

        // Convert Month
        stream.WriteByte(Convert.ToByte(dateTime.Month));

        // Convert Day
        stream.WriteByte(Convert.ToByte(dateTime.Day));

        // Convert WeekDay. NET DateTime starts with Sunday = 0, while S7DT has Sunday = 1.
        stream.WriteByte(Convert.ToByte(dateTime.DayOfWeek + 1));

        // Convert Hour
        stream.WriteByte(Convert.ToByte(dateTime.Hour));

        // Convert Minutes
        stream.WriteByte(Convert.ToByte(dateTime.Minute));

        // Convert Seconds
        stream.WriteByte(Convert.ToByte(dateTime.Second));

        // Convert Nanoseconds. Net DateTime has a representation of 1 Tick = 100ns.
        // Thus First take the ticks Mod 1 Second (1s = 10'000'000 ticks), and then Convert to nanoseconds.
        stream.Write(DWord.ToByteArray(Convert.ToUInt32((dateTime.Ticks % 10000000) * 100)), 0, 4);

        return stream.ToArray();
    }

    /// <summary>
    /// Converts an array of <see cref="T:System.DateTime" /> values to a byte array.
    /// </summary>
    /// <param name="dateTimes">The DateTime values to convert.</param>
    /// <returns>A byte array containing the S7 DateTimeLong representations of <paramref name="dateTimes" />.</returns>
    /// <exception cref="ArgumentOutOfRangeException">
    /// Thrown when any value of
    /// <paramref name="dateTimes" /> is before <see cref="P:SpecMinimumDateTime" />
    /// or after <see cref="P:SpecMaximumDateTime" />.
    /// </exception>
    public static byte[] ToByteArray(System.DateTime[] dateTimes)
    {
        if (dateTimes == null)
        {
            throw new ArgumentNullException(nameof(dateTimes));
        }

        var bytes = new List<byte>(dateTimes.Length * TypeLengthInBytes);
        foreach (var dateTime in dateTimes)
        {
            bytes.AddRange(ToByteArray(dateTime));
        }

        return [.. bytes];
    }

    private static System.DateTime FromByteArrayImpl(byte[] bytes)
    {
        if (bytes.Length != TypeLengthInBytes)
        {
            throw new ArgumentOutOfRangeException(nameof(bytes), bytes.Length, $"Parsing a DateTimeLong requires exactly 12 bytes of input data, input data is {bytes.Length} bytes long.");
        }

        var year = AssertRangeInclusive(Word.FromBytes(bytes[1], bytes[0]), 1970, 2262, "year");
        var month = AssertRangeInclusive(bytes[2], 1, 12, "month");
        var day = AssertRangeInclusive(bytes[3], 1, 31, "day of month");
        var dayOfWeek = AssertRangeInclusive(bytes[4], 1, 7, "day of week");
        var hour = AssertRangeInclusive(bytes[5], 0, 23, "hour");
        var minute = AssertRangeInclusive(bytes[6], 0, 59, "minute");
        var second = AssertRangeInclusive(bytes[7], 0, 59, "second");

        var nanoseconds = AssertRangeInclusive<uint>(DWord.FromBytes(bytes[11], bytes[10], bytes[9], bytes[8]), 0, 999999999, "nanoseconds");

        var time = new System.DateTime(year, month, day, hour, minute, second);
        return time.AddTicks(nanoseconds / 100);
    }

    private static T AssertRangeInclusive<T>(T input, T min, T max, string field)
        where T : IComparable<T>
    {
        if (input.CompareTo(min) < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(input), input, $"Value '{input}' is lower than the minimum '{min}' allowed for {field}.");
        }

        if (input.CompareTo(max) > 0)
        {
            throw new ArgumentOutOfRangeException(nameof(input), input, $"Value '{input}' is higher than the maximum '{max}' allowed for {field}.");
        }

        return input;
    }
}
